home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Source Code / Mark Pilgrim / Lose Your Marbles! 1.0 / source / Shell ƒ / menus.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-10-30  |  11.6 KB  |  485 lines  |  [TEXT/KAHL]
  1. /**********************************************************************\
  2.  
  3. File:        menus.c
  4.  
  5. Purpose:    This module handles menu selections.
  6.  
  7. This program is free software; you can redistribute it and/or modify
  8. it under the terms of the GNU General Public License as published by
  9. the Free Software Foundation; either version 2 of the License, or
  10. (at your option) any later version.
  11.  
  12. This program is distributed in the hope that it will be useful,
  13. but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. GNU General Public License for more details.
  16.  
  17. You should have received a copy of the GNU General Public License
  18. along with this program in a file named "GNU General Public License".
  19. If not, write to the Free Software Foundation, 675 Mass Ave,
  20. Cambridge, MA 02139, USA.
  21.  
  22. \**********************************************************************/
  23.  
  24. #include "graphics.h"
  25. #include "menus.h"
  26. #include "help.h"
  27. #include "environment.h"
  28. #include "sounds.h"
  29. #include "error.h"
  30. #include "launch.h"
  31. #include "file interface.h"
  32. #include "ls load-save.h"
  33. #include "ls endgame.h"
  34. #include "ls find.h"
  35. #include "ls shift.h"
  36. #include "ls.h"
  37. #include "debinhex dispatch.h"
  38. #include "file management.h"
  39. #include "program globals.h"
  40.  
  41. extern    long        menuDisable : 0x0b54;
  42.  
  43. Boolean            gMenuEnabled;
  44. MenuHandle        gAppleMenu;
  45. MenuHandle        gFileMenu;
  46. MenuHandle        gEditMenu;
  47. MenuHandle        gOptionsMenu;
  48. MenuHandle        gBoardMenu;
  49. MenuHandle        gPlayMenu;
  50.  
  51. enum
  52. {
  53.     appleMenu = 400, fileMenu, editMenu, optionsMenu, playMenu,
  54.     
  55.     aboutItem = 1, aboutMSGItem, helpPointerItem,
  56.     
  57.     newItem = 1, openItem, closeItem, saveItem, saveAsItem, deBinHexItem = 7,
  58.         launchItem=9, forceQuitItem = 11, quitItem,
  59.     
  60.     undoItem = 1, cutItem = 3, copyItem, pasteItem, clearItem, selectAllItem,
  61.     
  62.     soundToggle = 1, options_unused1, board5, board6, board7, board8, options_unused2,
  63.         hideItem,
  64.     
  65.     findItem=1, play_unused1, shiftLeftItem, shiftRightItem, shiftUpItem, shiftDownItem
  66. };
  67.  
  68. /*-----------------------------------------------------------------------------------*/
  69. /* internal stuff for menus.c                                                        */
  70.  
  71. static    void HandleAppleMenu(short menuItem);
  72. static    void HandleFileMenu(short menuItem);
  73. static    void HandleEditMenu(short menuItem);
  74. static    void HandleHelpMenu(void);
  75. static    void HandleOptionsMenu(short menuItem);
  76. static    void HandlePlayMenu(short menuItem);
  77.  
  78. Boolean InitTheMenus(void)
  79. {
  80.     Handle        MBARHandle;
  81.     
  82.     if ((MBARHandle=GetNewMBar(400))==0L)        /* sez which menus are in menu bar. */
  83.         return FALSE;
  84.     SetMenuBar(MBARHandle);                        /* set this to be THE menu bar to use. */
  85.     
  86.     if ((gAppleMenu=GetMHandle(appleMenu))==0L)    /* GetNewMBar also got menu handles of */
  87.         return FALSE;
  88.     if ((gFileMenu=GetMHandle(fileMenu))==0L)    /* every menu it includes, so just */
  89.         return FALSE;
  90.     if ((gEditMenu=GetMHandle(editMenu))==0L)    /* grab these handles and assign them */
  91.         return FALSE;
  92.     if ((gOptionsMenu=GetMHandle(optionsMenu))==0L)
  93.         return FALSE;
  94.     if ((gPlayMenu=GetMHandle(playMenu))==0L)
  95.         return FALSE;
  96.     
  97.     if (gSystemSevenOrLater)
  98.     {
  99.         AppendMenu(gOptionsMenu, "\p-");
  100.         AppendMenu(gOptionsMenu, "\pHide/1");
  101.     }
  102.     
  103.     AddResMenu(gAppleMenu, 'DRVR');                /* adds control panels to apple menu */
  104.     
  105.     AdjustMenus();                                /* dim/enable/check/mark menus/items */
  106.     DrawMenuBar();                                /* draws the actual menu bar */
  107.     
  108.     return TRUE;
  109. }
  110.  
  111. void AdjustMenus(void)
  112. {
  113.     WindowPeek        theWindow;
  114.     short            kind;
  115.     short            i;
  116.     
  117.     if (gInProgress)
  118.     {
  119.         DisableItem(gAppleMenu, aboutItem);
  120.         DisableItem(gAppleMenu, aboutMSGItem);
  121.         DisableItem(gAppleMenu, helpPointerItem);
  122.         if (gSystemSevenOrLater)
  123.         {
  124.             DisableItem(gFileMenu, newItem);
  125.             DisableItem(gFileMenu, openItem);
  126.             DisableItem(gFileMenu, closeItem);
  127.             DisableItem(gFileMenu, deBinHexItem);
  128.             DisableItem(gFileMenu, launchItem);
  129.             DisableItem(gFileMenu, quitItem);
  130.         }
  131.         else DisableItem(gFileMenu, 0);
  132.         
  133.         DisableItem(gEditMenu, 0);
  134.         DisableItem(gOptionsMenu, 0);
  135.         DisableItem(gPlayMenu, 0);
  136.     }
  137.     else
  138.     {
  139.         EnableItem(gAppleMenu, aboutItem);
  140.         EnableItem(gAppleMenu, aboutMSGItem);
  141.         EnableItem(gAppleMenu, helpPointerItem);
  142.         if (gSystemSevenOrLater)
  143.         {
  144.             EnableItem(gFileMenu, newItem);
  145.             EnableItem(gFileMenu, openItem);
  146.             EnableItem(gFileMenu, closeItem);
  147.             EnableItem(gFileMenu, deBinHexItem);
  148.             EnableItem(gFileMenu, launchItem);
  149.             EnableItem(gFileMenu, quitItem);
  150.         }
  151.         else EnableItem(gFileMenu, 0);
  152.         EnableItem(gEditMenu, 0);
  153.         EnableItem(gOptionsMenu, 0);
  154.         
  155.         theWindow = (WindowPeek)FrontWindow();
  156.         kind = theWindow ? theWindow->windowKind : 0;
  157.         
  158.         if (kind < 0)
  159.         {
  160.             EnableItem(gEditMenu, undoItem);
  161.             EnableItem(gEditMenu, cutItem);
  162.             EnableItem(gEditMenu, copyItem);
  163.             EnableItem(gEditMenu, pasteItem);
  164.             EnableItem(gEditMenu, clearItem);
  165.         }
  166.         else
  167.         {
  168.             if ((theWindow!=0L) && ((WindowPtr)theWindow==GetIndWindowGrafPtr(kMainWindow)) &&
  169.                 (gNumMoves>0) && (!ShowingFindQQ()) && (!ShowingEndGameQQ()))
  170.                 EnableItem(gEditMenu, undoItem);
  171.             else
  172.                 DisableItem(gEditMenu, undoItem);
  173.             DisableItem(gEditMenu, cutItem);
  174.             DisableItem(gEditMenu, copyItem);
  175.             DisableItem(gEditMenu, pasteItem);
  176.             DisableItem(gEditMenu, clearItem);
  177.         }
  178.         
  179.         if (theWindow)
  180.             EnableItem(gFileMenu, closeItem);
  181.         else
  182.             DisableItem(gFileMenu, closeItem);
  183.         
  184.         if (GetIndWindowGrafPtr(kMainWindow))
  185.         {
  186.             DisableItem(gFileMenu, newItem);
  187.             DisableItem(gFileMenu, openItem);
  188.             EnableItem(gFileMenu, saveItem);
  189.             EnableItem(gFileMenu, saveAsItem);
  190.             DisableItem(gOptionsMenu, board5);
  191.             DisableItem(gOptionsMenu, board6);
  192.             DisableItem(gOptionsMenu, board7);
  193.             DisableItem(gOptionsMenu, board8);
  194.             if (ShowingEndGameQQ() || ShowingFindQQ())
  195.                 DisableItem(gPlayMenu, 0);
  196.             else
  197.                 EnableItem(gPlayMenu, 0);
  198.         }
  199.         else
  200.         {
  201.             EnableItem(gFileMenu, newItem);
  202.             EnableItem(gFileMenu, openItem);
  203.             DisableItem(gFileMenu, saveItem);
  204.             DisableItem(gFileMenu, saveAsItem);
  205.             EnableItem(gOptionsMenu, board5);
  206.             EnableItem(gOptionsMenu, board6);
  207.             EnableItem(gOptionsMenu, board7);
  208.             EnableItem(gOptionsMenu, board8);
  209.             DisableItem(gPlayMenu, 0);
  210.         }
  211.         
  212.         if (gSystemSevenOrLater)
  213.             EnableItem(gFileMenu, forceQuitItem);
  214.         else
  215.             DisableItem(gFileMenu, forceQuitItem);
  216.         
  217.         if (gSoundAvailable)
  218.             EnableItem(gOptionsMenu, soundToggle);
  219.         else
  220.             DisableItem(gOptionsMenu, soundToggle);
  221.     }
  222.     CheckItem(gOptionsMenu, soundToggle, gSoundToggle&&gSoundAvailable);
  223.     for (i=0; i<=MAX_ROWS-5; i++)
  224.         CheckItem(gOptionsMenu, board5+i, (gNumRows==(i+5)));
  225. }
  226.  
  227. void HandleMenu(long mSelect)
  228. {
  229.     short            menuID = HiWord(mSelect);
  230.     short            menuItem = LoWord(mSelect);
  231.     
  232.     if (menuID==0)
  233.     {
  234.         menuID=HiWord(menuDisable);
  235.         menuItem=LoWord(menuDisable);
  236.         gMenuEnabled=FALSE;
  237.     }
  238.     else gMenuEnabled=TRUE;
  239.     menuDisable=0L;
  240.  
  241.     switch (menuID)
  242.     {
  243.         case appleMenu:
  244.             HandleAppleMenu(menuItem);
  245.             break;
  246.         case fileMenu:
  247.             HandleFileMenu(menuItem);
  248.             break;    
  249.         case editMenu:
  250.             HandleEditMenu(menuItem);
  251.             break;
  252.         case optionsMenu:
  253.             HandleOptionsMenu(menuItem);
  254.             break;
  255.         case playMenu:
  256.             HandlePlayMenu(menuItem);
  257.             break;
  258.     }
  259. }
  260.  
  261. void DoTheCloseThing(WindowPeek theWindow)
  262. /* a standard close procedure, called when "close" is chosen from File menu and when
  263.    a window is closed through its close box */
  264. {
  265.     Boolean            gotone;
  266.     short            i;
  267.     short            kind;
  268.     
  269.     if (theWindow==0L)
  270.         return;
  271.     
  272.     kind = theWindow ? theWindow->windowKind : 0;
  273.     if (kind<0)        /* DA window or other system window */
  274.         CloseDeskAcc(kind);
  275.     else
  276.     {
  277.         gotone=FALSE;
  278.         /* see if it's one of ours */
  279.         for (i=0; (i<NUM_WINDOWS) && (!gotone); i++)
  280.             gotone=((WindowPtr)theWindow==GetIndWindowGrafPtr(i));
  281.         
  282.         if (gotone)        /* if it's one of ours...  see graphics.c */
  283.             CloseTheIndWindow(i-1);            /* this may return FALSE = not closed */
  284.         else
  285.             DisposeWindow((WindowPtr)theWindow);    /* not one of ours, so just close it */
  286.     
  287.         AdjustMenus();    /* may affect which menu items or menus are available, etc */
  288.     }
  289. }
  290.  
  291. void HandleAppleMenu(short menuItem)
  292. {
  293.     GrafPtr        savePort;
  294.     Str255        name;
  295.     
  296.     switch (menuItem)
  297.     {
  298.         case aboutItem:
  299.             if (gMenuEnabled)
  300.                 OpenTheIndWindow(kAbout);
  301.             else DoSound(sound_fluff, TRUE);
  302.             break;
  303.         case aboutMSGItem:
  304.             if (gMenuEnabled)
  305.                 OpenTheIndWindow(kAboutMSG);
  306.             else DoSound(sound_fluff, TRUE);
  307.             break;
  308.         case helpPointerItem:
  309.             if (gMenuEnabled)
  310.                 HandleHelpMenu();
  311.             else DoSound(sound_fluff, TRUE);
  312.             break;
  313.         default:
  314.             if (menuItem > helpPointerItem+1)
  315.             {
  316.                 GetPort(&savePort);
  317.                 GetItem(gAppleMenu, menuItem, name);
  318.                 OpenDeskAcc(name);
  319.                 SetPort(savePort);
  320.             }
  321.             break;
  322.     }
  323. }
  324.  
  325. void HandleFileMenu(short menuItem)
  326. {
  327.     WindowPtr            theWindow;
  328.     short                i;
  329.     Boolean                gotone;
  330.     
  331.     switch (menuItem)
  332.     {
  333.         case newItem:
  334.             if (gMenuEnabled)
  335.                 NewGame();
  336.             else DoSound(sound_fluff, TRUE);
  337.             break;
  338.         case openItem:
  339.             if (gMenuEnabled)
  340.                 LoadSaveDispatch(TRUE, FALSE);
  341.             else DoSound(sound_fluff, TRUE);
  342.             break;
  343.         case closeItem:
  344.             if (gMenuEnabled)
  345.                 DoTheCloseThing((WindowPeek)FrontWindow());
  346.             else DoSound(sound_fluff, TRUE);
  347.             break;
  348.         case saveItem:
  349.             if (gMenuEnabled)
  350.                 LoadSaveDispatch(FALSE, TRUE);
  351.             else DoSound(sound_fluff, TRUE);
  352.             break;
  353.         case saveAsItem:
  354.             if (gMenuEnabled)
  355.                 LoadSaveDispatch(FALSE, FALSE);
  356.             else DoSound(sound_fluff, TRUE);
  357.             break;
  358.         case deBinHexItem:
  359.             if (gMenuEnabled)
  360.             {
  361.                 if (GetSourceFile(&inputFS, TRUE, FALSE))
  362.                     HandleError(DeBinHexDispatch(), FALSE);
  363.             }
  364.             else DoSound(sound_fluff, TRUE);
  365.             break;
  366.         case launchItem:
  367.             if (gMenuEnabled)
  368.             {
  369.                 LaunchDispatch();
  370.             }
  371.             else DoSound(sound_fluff, TRUE);
  372.             break;
  373.         case forceQuitItem:
  374.             if (gMenuEnabled)
  375.                 SysError(0x4e22);
  376.             else DoSound(sound_fluff, TRUE);
  377.             break;
  378.         case quitItem:
  379.             if (gMenuEnabled)
  380.                 gDone = TRUE;
  381.             else DoSound(sound_fluff, TRUE);
  382.             break;
  383.     }
  384. }
  385.  
  386. void HandleEditMenu(short menuItem)
  387. {
  388.     if ((gMenuEnabled) && (menuItem!=2) && (menuItem>0))
  389.     {
  390.         if (gFrontWindowIsOurs)
  391.         {
  392.             switch (menuItem)
  393.             {
  394.                 case undoItem:        CallIndDispatchProc(gFrontWindowIndex, kUndo, 0L);    break;
  395.                 case cutItem:        CallIndDispatchProc(gFrontWindowIndex, kCut, 0L);    break;
  396.                 case copyItem:        CallIndDispatchProc(gFrontWindowIndex, kCopy, 0L);    break;
  397.                 case pasteItem:        CallIndDispatchProc(gFrontWindowIndex, kPaste, 0L);    break;
  398.                 case clearItem:        CallIndDispatchProc(gFrontWindowIndex, kClear, 0L);    break;
  399.                 case selectAllItem:    CallIndDispatchProc(gFrontWindowIndex, kSelectAll, 0L);    break;
  400.             }
  401.         }
  402.         else SystemEdit(menuItem-1);
  403.     }
  404.     else if ((menuItem!=2) && (menuItem>0))
  405.         DoSound(sound_fluff, TRUE);
  406. }
  407.  
  408. void HandleOptionsMenu(short menuItem)
  409. {
  410.     switch (menuItem)
  411.     {
  412.         case soundToggle:
  413.             if (gMenuEnabled)
  414.             {
  415.                 gSoundToggle=!gSoundToggle;
  416.                 DoSound(sound_on, TRUE);
  417.             }
  418.             break;
  419.         case board5:
  420.         case board6:
  421.         case board7:
  422.         case board8:
  423.             if (gMenuEnabled)
  424.             {
  425.                 gNumRows=gNumColumns=menuItem-board5+5;
  426.             }
  427.             else DoSound(sound_fluff, TRUE);
  428.             break;
  429.         case hideItem:
  430.             if (gMenuEnabled)
  431.             {
  432.                 MenuKey(0);
  433.             }
  434.             else DoSound(sound_fluff, TRUE);
  435.             break;
  436.     }
  437. }
  438.  
  439. void HandleHelpMenu(void)
  440. {
  441.     OpenTheIndWindow(kHelp);
  442. }
  443.  
  444. void HandlePlayMenu(short menuItem)
  445. {
  446.     switch (menuItem)
  447.     {
  448.         case findItem:
  449.             if (gMenuEnabled)
  450.             {
  451.                 FindDispatch(GetIndWindowDataHandle(kMainWindow));
  452.             }
  453.             else DoSound(sound_fluff, TRUE);
  454.             break;
  455.         case shiftLeftItem:
  456.             if (gMenuEnabled)
  457.             {
  458.                 ShiftLeftDispatch(GetIndWindowDataHandle(kMainWindow));
  459.             }
  460.             else DoSound(sound_fluff, TRUE);
  461.             break;
  462.         case shiftRightItem:
  463.             if (gMenuEnabled)
  464.             {
  465.                 ShiftRightDispatch(GetIndWindowDataHandle(kMainWindow));
  466.             }
  467.             else DoSound(sound_fluff, TRUE);
  468.             break;
  469.         case shiftUpItem:
  470.             if (gMenuEnabled)
  471.             {
  472.                 ShiftUpDispatch(GetIndWindowDataHandle(kMainWindow));
  473.             }
  474.             else DoSound(sound_fluff, TRUE);
  475.             break;
  476.         case shiftDownItem:
  477.             if (gMenuEnabled)
  478.             {
  479.                 ShiftDownDispatch(GetIndWindowDataHandle(kMainWindow));
  480.             }
  481.             else DoSound(sound_fluff, TRUE);
  482.             break;
  483.     }
  484. }
  485.